var express = require('express');
var Msdb = require("../../../db/Mysqldb.js");
var router = express.Router();   //可使用 express.Router 类创建模块化、可挂载的路由句柄

var db = new Msdb();
var getTime=()=>{
    return new Date(new Date().getTime()+8 * 60 * 60 * 1000).toISOString().slice(0, 19).replace('T', ' ');//获取系统时间并转为数据库接受的格式
}

router.get("/getRoleList",async function(req,res){//获取可选角色列表
    var roleList=await db.query(`SELECT * FROM role WHERE id!=1`)
    res.send(JSON.stringify(roleList))
})

router.post("/getRoles",async function(req,res){//获取角色信息
    var roles=await db.query(`SELECT * FROM role LIMIT ? OFFSET ?;`,[req.body.pageSize,req.body.offset])
    const [countResult] = await db.query(`SELECT COUNT(*) AS total FROM role`);//统计角色总数
    result={
        data:roles,
        total:countResult.total
    }
    res.send(JSON.stringify(result))
})

router.post("/addRole",async function(req,res){//新增角色
    // 获取数据库连接
    const connection = await db.getConnection();
    var result={}
    var data=req.body
    
    try {
        if(data.role_id==1||data.role_id==3){//权限通过
            // 使用事务连接执行查询
            const idResult = await connection.execute(`SELECT id FROM role WHERE role_name=?`,[data.role_name]);
            const id = idResult[0];
            
            if(id.length!=0){//角色名称已存在
                result={
                    code:201,
                    msg:"角色名称已存在，请修改名称"
                }
            } else {
                // 开启事务
                await db.beginTransaction(connection);
                
                // 新增角色
                await connection.execute(`INSERT INTO role (role_name,is_sys) VALUES (?,?)`,[data.role_name,0]);
                
                // 记录操作日志
                var sql_words=`INSERT INTO role (role_name,is_sys) VALUES (${data.role_name},0)`;
                var time=getTime();
                await connection.execute(`INSERT INTO operation_log (user_id,sql_words,time) VALUES (?,?,?);`,[data.user_id,sql_words,time]);
                
                // 提交事务
                await db.commit(connection);
                
                result={
                    code:200,
                    msg:"角色新增成功"
                }
            }
        } else {
            result={
                code:201,
                msg:"当前账号不属于超级管理员/系统运维专员，无法新增角色！"
            }
        }
        res.send(JSON.stringify(result));
    } catch (error) {
        // 回滚事务
        await db.rollback(connection);
        console.error('新增角色错误:', error);
        result={
            code:500,
            msg:"服务器错误，新增角色失败"
        }
        res.send(JSON.stringify(result));
    } finally {
        // 释放连接
        connection.release();
    }
})

router.post('/delete',async function(req,res){//删除某个角色
    // 获取数据库连接
    const connection = await db.getConnection();
    var result={}
    
    try {
        // 查询角色是否为系统内置
        const isSysResult = await connection.execute(`SELECT is_sys FROM role WHERE id = ?`,[req.body.role_id]);
        const is_sys = isSysResult[0];
        
        if(is_sys[0].is_sys){//系统内置角色不允许删除
            result={
                code:201,
                msg:"系统内置角色不允许删除"
            }
        } else {
            if(!(req.auth.role_id==1||req.auth.role_id==3)){
                result={
                    code:201,
                    msg:"该操作需超级管理员/系统运维专员权限"
                }
            } else {//进行删除
                // 开启事务
                await db.beginTransaction(connection);
                
                // 将该角色用户全部分配到默认用户
                await connection.execute(`UPDATE user SET role_id=2 WHERE role_id=?`,[req.body.role_id]);
                
                // 删除该角色
                await connection.execute(`DELETE FROM role WHERE id=?`,[req.body.role_id]);
                
                // 记录操作日志
                var sql_words=`DELETE FROM role WHERE role_id=${req.body.role_id}`;
                var time=getTime();
                await connection.execute(`INSERT INTO operation_log (user_id,sql_words,time) VALUES (?,?,?);`,[req.auth.user_id,sql_words,time]);
                
                // 提交事务
                await db.commit(connection);
                
                result={
                    code:200,
                    msg:"删除成功"
                }
            }
        }
        res.send(JSON.stringify(result));
    } catch (error) {
        // 回滚事务
        await db.rollback(connection);
        console.error('删除角色错误:', error);
        result={
            code:500,
            msg:"服务器错误，删除角色失败"
        }
        res.send(JSON.stringify(result));
    } finally {
        // 释放连接
        connection.release();
    }
})

router.post('/getInfoById', async function(req, res) {
    // 根据角色id查出详细信息，角色名称，可浏览菜单与不可浏览菜单
    var result = {};
    try {
        // 获取角色名称
        const roleResult = await db.query(`SELECT role_name FROM role WHERE id=?`, [req.body.id]);
        if (roleResult.length === 0) {
            return res.status(404).json({ error: '角色不存在' });
        }
        const role_name = roleResult[0].role_name;
        
        // 获取所有菜单
        const menusResult = await db.query(`SELECT * FROM menu`);
        
        // 处理菜单，添加父菜单名称并转换为树形结构所需格式
        const menuMap = {};
        const menus = [];
        
        // 首先创建所有菜单的基础结构，并建立id到菜单的映射
        menusResult.forEach(menu => {
            menuMap[menu.id] = {
                key: menu.id.toString(),  // antd树形组件需要字符串类型的key
                value: menu.id.toString(), // 用于选择的值
                title: menu.title,         // 显示的标题
                id: menu.id,
                path: menu.path,
                parent_menu_id: menu.parent_menu_id,
                is_sys: menu.is_sys,
                children: []               // 用于存放子菜单
            };
        });
        
        // 构建树形结构
        menusResult.forEach(menu => {
            const menuItem = menuMap[menu.id];
            
            // 查找父菜单标题
            if (menu.parent_menu_id === null) {
                menuItem.parentMenu = "无";
                // 顶级菜单直接加入根数组
                menus.push(menuItem);
            } else {
                const parentMenu = menuMap[menu.parent_menu_id];
                menuItem.parentMenu = parentMenu ? parentMenu.title : "未知";
                
                // 将当前菜单添加到父菜单的children中
                if (parentMenu) {
                    parentMenu.children.push(menuItem);
                } else {
                    // 如果父菜单不存在，作为顶级菜单处理
                    menus.push(menuItem);
                }
            }
        });
        
        // 查询出所有有权限的菜单
        const okMenusResult = await db.query(`
            SELECT m.id, title, path, parent_menu_id, is_sys
            FROM menu m
            INNER JOIN user_menu_permission ump 
                ON m.id = ump.menu_id
            WHERE ump.role_id = ?;
        `, [req.body.id]);
        
        // 处理有权限的菜单，转换为树形结构
        const okMenuMap = {};
        const ok_menus = [];
        
        okMenusResult.forEach(menu => {
            okMenuMap[menu.id] = {
                key: menu.id.toString(),
                value: menu.id.toString(),
                title: menu.title,
                id: menu.id,
                path: menu.path,
                parent_menu_id: menu.parent_menu_id,
                is_sys: menu.is_sys,
                children: []
            };
        });
        
        okMenusResult.forEach(menu => {
            const menuItem = okMenuMap[menu.id];
            if (menu.parent_menu_id === null) {
                ok_menus.push(menuItem);
            } else {
                const parentMenu = okMenuMap[menu.parent_menu_id];
                if (parentMenu) {
                    parentMenu.children.push(menuItem);
                } else {
                    ok_menus.push(menuItem);
                }
            }
        });
        
        // 处理无权限的菜单，转换为树形结构
        const noMenuIds = menusResult
            .filter(menu => !okMenuMap[menu.id])
            .map(menu => menu.id);
            
        const noMenuMap = {};
        const no_menus = [];
        
        noMenuIds.forEach(menuId => {
            const menu = menusResult.find(m => m.id === menuId);
            noMenuMap[menuId] = {
                key: menu.id.toString(),
                value: menu.id.toString(),
                title: menu.title,
                id: menu.id,
                path: menu.path,
                parent_menu_id: menu.parent_menu_id,
                is_sys: menu.is_sys,
                children: []
            };
        });
        
        noMenuIds.forEach(menuId => {
            const menu = menusResult.find(m => m.id === menuId);
            const menuItem = noMenuMap[menuId];
            
            if (menu.parent_menu_id === null) {
                no_menus.push(menuItem);
            } else {
                // 检查父菜单是否也在无权限列表中
                if (noMenuMap[menu.parent_menu_id]) {
                    noMenuMap[menu.parent_menu_id].children.push(menuItem);
                } else {
                    no_menus.push(menuItem);
                }
            }
        });
        
        // 构建返回结果
        result = {
            role_name: role_name,
            ok_menus: ok_menus,     // 有权限的菜单（树形结构）
            no_menus: no_menus,     // 无权限的菜单（树形结构）
            all_menus: menus,       // 所有菜单（树形结构）
            id: req.body.id
        };
        
        res.json(result);
    } catch (error) {
        res.status(500).json({ error: '获取角色信息失败' });
    }
})

router.post('/updateRoleName',async function (req,res) {//更新角色名称
    // 获取数据库连接
    const connection = await db.getConnection();
    var result={}
    var data=req.body
    
    try {
        if(req.auth.role_id==1||req.auth.role_id==3){//权限通过
            // 检查角色名称是否已存在
            const idResult = await connection.execute(`SELECT id FROM role WHERE role_name=?`,[data.role_name]);
            const id = idResult[0];
            
            if(id.length!=0){//角色名称已存在
                result={
                    code:201,
                    msg:"角色名称已存在，请修改名称"
                }
            } else {
                // 开启事务
                await db.beginTransaction(connection);
                
                // 更新角色名称
                await connection.execute(`UPDATE role SET role_name=? WHERE id=?`,[data.role_name,data.id]);
                
                // 记录操作日志
                var sql_words=`UPDATE role SET role_name=${data.role_name} WHERE id=${data.id}`;
                var time=getTime();
                await connection.execute(`INSERT INTO operation_log (user_id,sql_words,time) VALUES (?,?,?);`,[req.auth.user_id,sql_words,time]);
                
                // 提交事务
                await db.commit(connection);
                
                result={
                    code:200,
                    msg:"角色修改成功"
                }
            }
        } else {
            result={
                code:201,
                msg:"当前账号不属于超级管理员/系统运维专员，无法编辑角色！"
            }
        }
        res.send(JSON.stringify(result));
    } catch (error) {
        // 回滚事务
        await db.rollback(connection);
        result={
            code:500,
            msg:"服务器错误，更新角色名称失败"
        }
        res.send(JSON.stringify(result));
    } finally {
        // 释放连接
        connection.release();
    }
})

router.post('/updateUserMenuPermission',async function (req,res) {//更新角色菜单权限
    // 获取数据库连接
    const connection = await db.getConnection();
    var result={}
    var data=req.body
    
    try {
        if(req.auth.role_id==1||req.auth.role_id==3){//角色校验通过
            // 开启事务
            await db.beginTransaction(connection);
            
            // 查出此角色旧的可浏览菜单id
            const okMenusResult = await connection.execute(`SELECT menu_id FROM user_menu_permission WHERE role_id=?`,[data.role_id]);
            var ok_menus = okMenusResult[0];
            
            for(var i=0;i<data.new_menus_id.length;i++){
                var is_ok=false;
                for(var j=0;j<ok_menus.length;j++){//遍历新的菜单是否与旧的重复
                    if(data.new_menus_id[i]==ok_menus[j].menu_id){
                        is_ok=true;//此菜单权限未变动，不用删除
                        ok_menus.splice(j, 1);
                        break;
                    }
                }
                if(!is_ok){//此菜单在旧的菜单权限未找到，需要新增
                    await connection.execute(`INSERT INTO user_menu_permission (role_id,menu_id) VALUES (?,?)`,[data.role_id,data.new_menus_id[i]]);
                    
                    var sql_words=`INSERT INTO user_menu_permission (role_id,menu_id) VALUES (${data.role_id},${data.new_menus_id[i]})`;
                    var time=getTime();
                    await connection.execute(`INSERT INTO operation_log (user_id,sql_words,time) VALUES (?,?,?);`,[req.auth.user_id,sql_words,time]);
                }
            }
            
            for(var i=0;i<ok_menus.length;i++){//这些ok_menus菜单没有被选中，说明已被删除权限
                await connection.execute(`DELETE FROM user_menu_permission WHERE role_id=? AND menu_id=?`,[data.role_id,ok_menus[i].menu_id]);
                
                var sql_words=`DELETE FROM user_menu_permission WHERE role_id=${data.role_id} AND menu_id=${ok_menus[i].menu_id}`;
                var time=getTime();
                await connection.execute(`INSERT INTO operation_log (user_id,sql_words,time) VALUES (?,?,?);`,[req.auth.user_id,sql_words,time]);
            }
            
            // 提交事务
            await db.commit(connection);
            
            result={
                code:200,
                msg:"权限更新完成，已为您刷新权限列表。"
            }
        } else {
            result={
                code:201,
                msg:"当前账号不属于超级管理员/系统运维专员，无法更新角色菜单！"
            }
        }
        res.send(JSON.stringify(result));
    } catch (error) {
        // 回滚事务
        await db.rollback(connection);
        result={
            code:500,
            msg:"服务器错误，更新角色菜单权限失败"
        }
        res.send(JSON.stringify(result));
    } finally {
        // 释放连接
        connection.release();
    }
})

module.exports = router;